{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Image Annotator for Labelling Images Into User-Defined Categories\n",
    "Adapted from : https://blogs.sas.com/content/subconsciousmusings/2021/11/23/introducing-jupicl-fast-image-labelling-entirely-within-a-jupyter-notebook/\n",
    "\n",
    "This code displays each image in dataset and allow user to specify weather conditions he can observe (cloudy or not).\n",
    "\n",
    "Input : PolarizedDatabase folder with cropped images grouped in numpy files, you can download all or only some of the \"YYYY-MM-DD_raw.npy\" file days to accelerate processing on your computer.\n",
    "\n",
    "Output : Files with same timestamps than input file in a column and annotations in another column.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import packages and define essential helper functions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#import cv2\n",
    "from IPython.display import display, clear_output\n",
    "from PIL import Image\n",
    "import os\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from datetime import datetime\n",
    "from collections import defaultdict\n",
    "import time\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "in_path=\"/scratch/lpoughon/PolarizedDatabase/\"\n",
    "calib_path=\"/scratch/lpoughon/PolarizedDatabase/calib/\"\n",
    "out_path=\"/scratch/lpoughon/PolarizedDatabase/\"\n",
    "limit_Zenith_Angle=np.pi*0.5 #Limit Zenith Angle to crop circularly data inside of camera field-of-view.\n",
    "\n",
    "dirs = os.listdir( in_path ) # Listing Files\n",
    "dirs_files=[]\n",
    "for file in dirs:\n",
    "    if file[-7:]=='raw.npy': # Keeping only ones with \".npy\" files. \n",
    "        dirs_files.append(file)\n",
    "dirs_files.sort() #We sort the files in alphabetical order. \n",
    "# Since the format is YYYY-MM-DDTHH-mm-ss.npy, the files are sorted in chronological order."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def rebin(arr, new_shape): #https://scipython.com/blog/binning-a-2d-array-in-numpy/\n",
    "    shape = (new_shape[0], arr.shape[0] // new_shape[0],\n",
    "             new_shape[1], arr.shape[1] // new_shape[1])\n",
    "    return arr.reshape(shape).mean(-1).mean(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def mkdict_from_user():\n",
    "    userdict = {}\n",
    "    while True:\n",
    "        res = input(\"Enter 'class_labels:keyboard_shortcut', such as 'bag:b', or 'q' to quit -->  \")\n",
    "        if res == 'q':\n",
    "            break\n",
    "        else:\n",
    "            key, val = res.split(':')\n",
    "            userdict[key] = val\n",
    "    \n",
    "    return userdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def get_userinput(user_labels):\n",
    "    \n",
    "    notes = 'default'\n",
    "    \n",
    "    valid_labels = tuple(user_labels.values())\n",
    "    \n",
    "    while True:\n",
    "        KBN = Keyborad_Shortcut_For_Notes = '7'\n",
    "        \n",
    "        userinput = input(f\"Valid Shortcuts: {valid_labels} <Append'{KBN}' for Notes> ... \")\n",
    "        \n",
    "        L = len(userinput)\n",
    "        if L not in [1,2]:\n",
    "            print('Invalid input, try again...')\n",
    "            continue\n",
    "        \n",
    "        if userinput[0] not in valid_labels:\n",
    "            print(f'Invalid input, valid labels are {valid_labels} try again...')\n",
    "            continue\n",
    "            \n",
    "        if L==2:\n",
    "            if userinput[1] != KBN:\n",
    "                print(f\"Invalid, second letter if present must be the keyboard shortcut for notes: '{KBN}' \")\n",
    "            else:\n",
    "                usernote  = input(\"Notes: \")\n",
    "                if len(usernote)>0:\n",
    "                    notes = usernote\n",
    "                break\n",
    "        \n",
    "        else:\n",
    "            break\n",
    "        \n",
    "    return userinput[0], notes\n",
    "            "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Define the main driver function for labelling"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "def goLabel_acq(user_labels, images_pola, liste_sortie_annotee):\n",
    "    #src_imgdir = f\"./images/\"\n",
    "\n",
    "    timestamps=images_pola[:,2]\n",
    "    # Convert timestamps to datetime objects\n",
    "    datetime_objects = [datetime.strptime(timestamp, '%Y-%m-%dT%H-%M-%S') for timestamp in timestamps]\n",
    "\n",
    "    # Round the minutes to the nearest 10 minutes\n",
    "    rounded_datetimes = [dt.replace(minute=(dt.minute // 10) * 10, second=0) for dt in datetime_objects]\n",
    "\n",
    "    # Group the timestamps into a dictionary based on rounded timestamps\n",
    "    result_dict = defaultdict(list)\n",
    "    result_dict_i = defaultdict(list)\n",
    "\n",
    "    for i, rounded_dt in enumerate(rounded_datetimes):\n",
    "        result_dict_i[rounded_dt].append(i)    \n",
    "        result_dict[rounded_dt].append(timestamps[i])\n",
    "\n",
    "    # Convert the defaultdict to a regular dictionary for a cleaner output (optional)\n",
    "    result_dict = dict(result_dict)\n",
    "\n",
    "    ## Print the result\n",
    "    #for key, value in result_dict_i.items():\n",
    "    #    print(f\"{key}: {value}\")\n",
    "    \n",
    "    \n",
    "    def plot_mosaic(images, rows, cols): # Function to display images in a mosaic plot\n",
    "        subsampl=4 #subsampling\n",
    "        fig, axs = plt.subplots(rows, cols, figsize=(cols*4, rows*4))\n",
    "        fig.suptitle(str(timestamp[0])+\" \")\n",
    "        for i, ax in enumerate(axs.flat):\n",
    "            if i < len(images):\n",
    "                img = images[i]\n",
    "                a=rebin(img,(img.shape[0]//2,img.shape[1]//2))\n",
    "                imgRGB = (np.stack([a[0::2,0::2],0.5*(a[0::2,1::2]+a[1::2,0::2]),a[1::2,1::2]], axis=2)/65520.0*255).astype('uint8')\n",
    "                #imgRGB = (np.stack([img[0::2,1::2],0.5*(img[0::2,1::2]+img[1::2,0::2]),img[1::2,1::2]], axis=2)/65520.0*255).astype('uint8')\n",
    "                ax.imshow(imgRGB[::subsampl,::subsampl])  # Assuming images are grayscale\n",
    "\n",
    "                #ax.imshow(img[::subsampl,::subsampl], cmap='gray')  # Assuming images are grayscale\n",
    "                ax.set_title(\"img_type \"+str(image_type[i])+\" \\n expo : \"+str(exposure[i])+\" µs\")\n",
    "\n",
    "\n",
    "                ax.axis('off')\n",
    "            else:\n",
    "                ax.remove()\n",
    "\n",
    "        return fig\n",
    "    \n",
    "\n",
    "    \n",
    "    sess_count = 0\n",
    "    \n",
    "    for my_datetime in (list(result_dict_i.keys())):\n",
    "        \n",
    "        # Extract image data, exposure, and timestamp from the array\n",
    "        indices_to_highlight=result_dict_i[my_datetime]\n",
    "        data = images_pola[indices_to_highlight,:]\n",
    "    \n",
    "    \n",
    "        images = data[:, 0]\n",
    "        exposure = data[:, 1]\n",
    "        timestamp = data[:, 2]\n",
    "        image_type=data[:,3]\n",
    "\n",
    "        N=data.shape[0]\n",
    "\n",
    "        sess_count += 1\n",
    "\n",
    "        # Specify the number of rows and columns in the mosaic\n",
    "        cols = 4\n",
    "        rows = N//cols+1\n",
    "\n",
    "\n",
    "        # Display the mosaic plot\n",
    "        mafig=plot_mosaic(images, rows, cols)\n",
    "        display(plt.gcf()) \n",
    "        #display(Image.fromarray(img))\n",
    "        print(f'Now Showing {timestamp[0]}'+\" (\"+str(sess_count)+\"/\"+str(len(list(result_dict_i.keys())))+\")\")\n",
    "        \n",
    "        label, notes = get_userinput(user_labels)\n",
    "        liste_sortie_annotee[indices_to_highlight,1]=label#'c'\n",
    "        print(\"Choisi : \",label)\n",
    "        #if notes != 'default':\n",
    "\n",
    "        \n",
    "        clear_output()\n",
    "        \n",
    "\n",
    "        plt.close()\n",
    "    \n",
    "\n",
    "    print(f\"You Labelled {sess_count} images in this round. Hooray!\")\n",
    "    return liste_sortie_annotee#Notes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "## Set up labels and keyboard shortcuts\n",
    "\n",
    "#### For example :\n",
    "\n",
    "dark_sky:n (night)\n",
    "\n",
    "clear_sky:c\n",
    "\n",
    "mist:m\n",
    "\n",
    "few_clouds:f (11-25%)\n",
    "\n",
    "scattered_clouds:s (25-50%) \n",
    "\n",
    "broken_clouds:b (51-84%)\n",
    "\n",
    "overcast_clouds:o (85-100%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "user_labels={'dark_sky': 'n',\n",
    " 'clear_sky': 'c',\n",
    " 'mist': 'm',\n",
    " 'few_clouds': 'f',\n",
    " 'scattered_clouds': 's',\n",
    " 'broken_clouds': 'b',\n",
    " 'overcast_clouds': 'o'}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "#user_labels = mkdict_from_user() #uncomment to change user labels"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Labelling days"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Annotated so far :"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dirs_ann = os.listdir( out_path ) # Listing Files\n",
    "dirs_ann_files=[]\n",
    "for file in dirs_ann:\n",
    "    if file[-19:]=='raw_annotations.npy': # Keeping only ones with \".npy\" files. \n",
    "        dirs_ann_files.append(file)\n",
    "dirs_ann_files.sort() #We sort the files in alphabetical order. \n",
    "#print(dirs_ann_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0   2022-07-29_raw.npy   2022-07-29_raw_annotations.npy\n",
      "1   2022-07-30_raw.npy   2022-07-30_raw_annotations.npy\n",
      "2   2022-07-31_raw.npy   2022-07-31_raw_annotations.npy\n",
      "3   2022-08-01_raw.npy   2022-08-01_raw_annotations.npy\n",
      "4   2022-08-02_raw.npy   2022-08-02_raw_annotations.npy\n",
      "5   2022-08-03_raw.npy   2022-08-03_raw_annotations.npy\n",
      "6   2022-08-04_raw.npy   2022-08-04_raw_annotations.npy\n",
      "7   2022-08-05_raw.npy   2022-08-05_raw_annotations.npy\n",
      "8   2022-08-06_raw.npy   2022-08-06_raw_annotations.npy\n",
      "9   2022-08-07_raw.npy   2022-08-07_raw_annotations.npy\n",
      "10   2022-08-08_raw.npy   2022-08-08_raw_annotations.npy\n",
      "11   2022-08-09_raw.npy   2022-08-09_raw_annotations.npy\n",
      "12   2022-08-10_raw.npy   2022-08-10_raw_annotations.npy\n",
      "13   2022-08-11_raw.npy   2022-08-11_raw_annotations.npy\n",
      "14   2022-08-12_raw.npy   2022-08-12_raw_annotations.npy\n",
      "15   2022-08-13_raw.npy   2022-08-13_raw_annotations.npy\n",
      "16   2022-08-14_raw.npy   2022-08-14_raw_annotations.npy\n",
      "17   2022-08-15_raw.npy   2022-08-15_raw_annotations.npy\n",
      "18   2022-08-16_raw.npy   2022-08-16_raw_annotations.npy\n",
      "19   2022-08-17_raw.npy   2022-08-17_raw_annotations.npy\n",
      "20   2022-08-18_raw.npy   2022-08-18_raw_annotations.npy\n",
      "21   2022-08-19_raw.npy   2022-08-19_raw_annotations.npy\n",
      "22   2022-08-20_raw.npy   2022-08-20_raw_annotations.npy\n",
      "23   2022-08-21_raw.npy   2022-08-21_raw_annotations.npy\n",
      "24   2022-08-22_raw.npy   2022-08-22_raw_annotations.npy\n",
      "25   2022-08-23_raw.npy   2022-08-23_raw_annotations.npy\n",
      "26   2022-08-24_raw.npy   2022-08-24_raw_annotations.npy\n",
      "27   2022-08-25_raw.npy   2022-08-25_raw_annotations.npy\n",
      "28   2022-08-26_raw.npy   2022-08-26_raw_annotations.npy\n",
      "29   2022-08-27_raw.npy   2022-08-27_raw_annotations.npy\n",
      "30   2022-08-28_raw.npy   2022-08-28_raw_annotations.npy\n",
      "31   2022-08-29_raw.npy   2022-08-29_raw_annotations.npy\n"
     ]
    }
   ],
   "source": [
    "liste_dates=[]\n",
    "for i in range(len(dirs_files)):\n",
    "    rec=dirs_files[i].split('_raw.npy')[0]+'_raw_annotations.npy'\n",
    "    liste_dates.append(dirs_files[i].split('_raw.npy')[0])\n",
    "    if rec in dirs_ann_files:\n",
    "        print(i,\" \",dirs_files[i],\" \",rec)\n",
    "    else:\n",
    "        print(i,\" \",dirs_files[i])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Choose file to annotate by changing the number you want"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Day number :  12\n",
      "File used : /scratch/lpoughon/PolarizedDatabase/2022-08-10_raw.npy\n",
      "Will save results in :/scratch/lpoughon/PolarizedDatabase/2022-08-10_raw_annotations.npy\n"
     ]
    }
   ],
   "source": [
    "day_wanted=12# Change that to choose what day to annotate\n",
    "print(\"Day number : \",day_wanted)\n",
    "print(\"File used :\",in_path+dirs_files[day_wanted])\n",
    "images_pola=np.load(in_path+dirs_files[day_wanted],allow_pickle=True)\n",
    "save_path=out_path+dirs_files[day_wanted].split(\".npy\")[0]+\"_annotations.npy\"\n",
    "print(\"Will save results in :\"+save_path)\n",
    "#images=images_pola[:,0]\n",
    "# the list that will contain timestamps and corresponding annotations\n",
    "liste_sortie_annotee=np.array(images_pola[:,2])\n",
    "liste_sortie_annotee=np.c_[liste_sortie_annotee,np.zeros(liste_sortie_annotee.shape[0])]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Let's annotate !"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "You Labelled 94 images in this round. Hooray!\n",
      "Labelling took  228  s\n"
     ]
    }
   ],
   "source": [
    "tic=time.time()\n",
    "labels=goLabel_acq(user_labels, images_pola, liste_sortie_annotee)\n",
    "print(\"Labelling took \",int(time.time()-tic),\" s\")\n",
    "np.save(save_path,labels)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "tags": []
   },
   "source": [
    "dark_sky:n (night)\n",
    "\n",
    "clear_sky:c\n",
    "\n",
    "few_clouds:f (11-25%)\n",
    "\n",
    "scattered_clouds:s (25-50%) \n",
    "\n",
    "broken_clouds:b (51-84%)\n",
    "\n",
    "overcast_clouds:o (85-100%)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'/scratch/lpoughon/PolarizedDatabase/2022-08-05_raw_annotations.npy'"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "save_path"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'user_labels' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "Cell \u001b[0;32mIn[1], line 1\u001b[0m\n\u001b[0;32m----> 1\u001b[0m \u001b[43muser_labels\u001b[49m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'user_labels' is not defined"
     ]
    }
   ],
   "source": [
    "user_labels"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['2022-07-29',\n",
       " '2022-07-30',\n",
       " '2022-07-31',\n",
       " '2022-08-01',\n",
       " '2022-08-02',\n",
       " '2022-08-03',\n",
       " '2022-08-04',\n",
       " '2022-08-05',\n",
       " '2022-08-06',\n",
       " '2022-08-07',\n",
       " '2022-08-08',\n",
       " '2022-08-09',\n",
       " '2022-08-10',\n",
       " '2022-08-11',\n",
       " '2022-08-12',\n",
       " '2022-08-13',\n",
       " '2022-08-14',\n",
       " '2022-08-15',\n",
       " '2022-08-16',\n",
       " '2022-08-17',\n",
       " '2022-08-18',\n",
       " '2022-08-19',\n",
       " '2022-08-20',\n",
       " '2022-08-21',\n",
       " '2022-08-22',\n",
       " '2022-08-23',\n",
       " '2022-08-24',\n",
       " '2022-08-25',\n",
       " '2022-08-26',\n",
       " '2022-08-27',\n",
       " '2022-08-28',\n",
       " '2022-08-29']"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "liste_dates"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "dirs_ann = os.listdir( out_path ) # Listing Files\n",
    "dirs_ann_files=[]\n",
    "for file in dirs_ann:\n",
    "    if file[-19:]=='raw_annotations.npy': # Keeping only ones with \".npy\" files. \n",
    "        dirs_ann_files.append(file)\n",
    "dirs_ann_files.sort() #We sort the files in alphabetical order. \n",
    "#print(dirs_ann_files)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": [
    "\n",
    "from datetime import datetime, timedelta\n",
    "\n",
    "\n",
    "def mosaique_meteos(dirs_ann_files,user_labels):\n",
    "    start_hour=6\n",
    "    end_hour=22\n",
    "    \n",
    "    liste_dates=[]\n",
    "    for filen in dirs_files:\n",
    "        liste_dates.append(filen.split(\"_raw\")[0])\n",
    "    print(liste_dates)\n",
    "    a=np.full((97,len(liste_dates)), 'missing')\n",
    "    \n",
    "    for file in dirs_ann_files:\n",
    "        print(file)\n",
    "        date=file.split(\"_raw\")[0]\n",
    "        id_date=np.where(np.array(liste_dates)==date)[0][0]\n",
    "        input_array=np.load(out_path+file,allow_pickle=True)\n",
    "        #input_array=np.array([[None,None]])\n",
    "    \n",
    "\n",
    "        # Function to convert timestamp to datetime object\n",
    "        def parse_timestamp(timestamp):\n",
    "            return datetime.strptime(timestamp, '%Y-%m-%dT%H-%M-%S')\n",
    "\n",
    "\n",
    "        current_date = parse_timestamp(input_array[0, 0]).replace(hour=0, minute=0, second=0, microsecond=0)\n",
    "        start_time = current_date + timedelta(hours=6)\n",
    "        end_time = current_date + timedelta(hours=22)\n",
    "        time_step = timedelta(minutes=10)\n",
    "        current_time = start_time\n",
    "        result_array = []\n",
    "\n",
    "        while current_time <= end_time:\n",
    "            timestamp_str = current_time.strftime('%Y-%m-%dT%H-%M-%S')\n",
    "            # Find the nearest timestamp in the input array\n",
    "            nearest_timestamp = min(input_array[:, 0], key=lambda x: abs(parse_timestamp(x) - current_time))\n",
    "            if parse_timestamp(nearest_timestamp) >= current_time and parse_timestamp(nearest_timestamp) <= current_time + time_step:\n",
    "                color = input_array[input_array[:, 0] == nearest_timestamp, 1][0]\n",
    "                result_array.append([timestamp_str, color])\n",
    "            else:\n",
    "                result_array.append([timestamp_str, 'missing'])\n",
    "            current_time += time_step\n",
    "\n",
    "\n",
    "        result_array=np.array(result_array)\n",
    "\n",
    "        a[:,id_date]=(np.array(result_array)[:,1])\n",
    "        \n",
    "    return a"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "tags": []
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "['2022-07-29', '2022-07-30', '2022-07-31', '2022-08-01', '2022-08-02', '2022-08-03', '2022-08-04', '2022-08-05', '2022-08-06', '2022-08-07', '2022-08-08', '2022-08-09', '2022-08-10', '2022-08-11', '2022-08-12', '2022-08-13', '2022-08-14', '2022-08-15', '2022-08-16', '2022-08-17', '2022-08-18', '2022-08-19', '2022-08-20', '2022-08-21', '2022-08-22', '2022-08-23', '2022-08-24', '2022-08-25', '2022-08-26', '2022-08-27', '2022-08-28', '2022-08-29']\n",
      "2022-07-29_raw_annotations.npy\n",
      "2022-07-30_raw_annotations.npy\n",
      "2022-07-31_raw_annotations.npy\n",
      "2022-08-01_raw_annotations.npy\n",
      "2022-08-02_raw_annotations.npy\n",
      "2022-08-03_raw_annotations.npy\n",
      "2022-08-04_raw_annotations.npy\n",
      "2022-08-05_raw_annotations.npy\n",
      "2022-08-06_raw_annotations.npy\n",
      "2022-08-07_raw_annotations.npy\n",
      "2022-08-08_raw_annotations.npy\n",
      "2022-08-09_raw_annotations.npy\n",
      "2022-08-10_raw_annotations.npy\n",
      "2022-08-11_raw_annotations.npy\n",
      "2022-08-12_raw_annotations.npy\n",
      "2022-08-13_raw_annotations.npy\n",
      "2022-08-14_raw_annotations.npy\n",
      "2022-08-15_raw_annotations.npy\n",
      "2022-08-16_raw_annotations.npy\n",
      "2022-08-17_raw_annotations.npy\n",
      "2022-08-18_raw_annotations.npy\n",
      "2022-08-19_raw_annotations.npy\n",
      "2022-08-20_raw_annotations.npy\n",
      "2022-08-21_raw_annotations.npy\n",
      "2022-08-22_raw_annotations.npy\n",
      "2022-08-23_raw_annotations.npy\n",
      "2022-08-24_raw_annotations.npy\n",
      "2022-08-25_raw_annotations.npy\n",
      "2022-08-26_raw_annotations.npy\n",
      "2022-08-27_raw_annotations.npy\n",
      "2022-08-28_raw_annotations.npy\n",
      "2022-08-29_raw_annotations.npy\n"
     ]
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 800x600 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from matplotlib.patches import Patch\n",
    "from matplotlib.ticker import FixedLocator, FuncFormatter, MultipleLocator\n",
    "\n",
    "# Define the color table\n",
    "color_table = mosaique_meteos(dirs_ann_files,user_labels)\n",
    "\n",
    "# Define a custom mapping of colors to RGB values\n",
    "color_mapping = {\n",
    "    'n': [0, 0, 0],\n",
    "    'c': [0, 0.7, 0],\n",
    "    'm': [0.5, 1, 0],\n",
    "    'f': [1, 1, 0],\n",
    "    's': [1, 0.5, 0],\n",
    "    'b': [1, 0, 0],\n",
    "    'o': [0.5, 0, 0.5],\n",
    "    'missing': [0.5, 0.5, 0.5]\n",
    "}\n",
    "\n",
    "# Convert color names to RGB values using the custom mapping\n",
    "rgb_colors = np.array([[color_mapping[color] for color in row] for row in color_table])\n",
    "\n",
    "# Create a figure and axes\n",
    "fig, ax = plt.subplots(figsize=(8, 6))\n",
    "\n",
    "# Create a pcolormesh plot using custom colors\n",
    "cax = ax.pcolormesh(np.arange(rgb_colors.shape[1] + 1),\n",
    "                    np.arange(rgb_colors.shape[0] + 1),\n",
    "                    rgb_colors)\n",
    "\n",
    "# Turn off axis labels\n",
    "#ax.axis('off')\n",
    "\n",
    "# Create a legend with custom color patches\n",
    "legend_patches = [\n",
    "    Patch(color=color_mapping['n'], label='Dark sky'),\n",
    "    Patch(color=color_mapping['c'], label='Clear sky'),\n",
    "    Patch(color=color_mapping['m'], label='Mist'),\n",
    "    Patch(color=color_mapping['f'], label='Few Clouds'),\n",
    "    Patch(color=color_mapping['s'], label='Scattered Clouds'),\n",
    "    Patch(color=color_mapping['b'], label='Broken Clouds'),\n",
    "    Patch(color=color_mapping['o'], label='Overcast Clouds'),\n",
    "    Patch(color=color_mapping['missing'], label='Missing Data')\n",
    "]\n",
    "\n",
    "# Add the legend to the plot\n",
    "ax.legend(handles=legend_patches, title='Legend', bbox_to_anchor=(1.05, 1), loc='upper left')\n",
    "\n",
    "#hours = np.arange(6, 22, 10/60)\n",
    "#hours = np.arange(6, 22, 2)  # Change the step to adjust the number of ticks\n",
    "#ax.set_yticks(np.arange(len(hours)) + 0.5)\n",
    "#ax.set_yticklabels([f'{int(h)}:{int((h % 1) * 60):02d}' for h in hours])\n",
    "#ax.set_yticklabels([])\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "# Add y-axis ticks and labels for time from 6:00 to 22:00 with 10-minute intervals\n",
    "#ax.set_yticks(np.arange(0.5, 16.5, 1))  # 16 rows from 6:00 to 22:00\n",
    "#ax.set_yticklabels([f'{hour:02d}:{minute:02d}' for hour in range(6, 23) for minute in range(0, 60, 10)])\n",
    "\n",
    "ytick_locations = np.arange(0, (22-6)*6, 6)\n",
    "ytick_labels = [f'{int(hour/6+6)}:00' for hour in ytick_locations]\n",
    "#print(ytick_locations)\n",
    "#print(ytick_labels)\n",
    "plt.yticks(ytick_locations, ytick_labels)\n",
    "plt.ylabel('Time')\n",
    "\n",
    "#ax.set_yticklabels([f'{int(h)}:00' for h in hours])\n",
    "ax.invert_yaxis()\n",
    "\n",
    "ax.set_xticks(np.arange(len(liste_dates)) + 0.5*0)\n",
    "ax.set_xticklabels(liste_dates,rotation='vertical')\n",
    "\n",
    "# Define custom minor tick locations for the x-axis\n",
    "#yticks_minor = ytick_locations# np.arange(0.5, 10.5, 1)\n",
    "\n",
    "# Define custom minor tick locations for the y-axis\n",
    "#xticks_minor = np.arange(0, 11, 1)\n",
    "\n",
    "\n",
    "ax.grid()\n",
    "\n",
    "# Define custom minor tick locations for the y-axis\n",
    "xticks_minor = np.arange(len(liste_dates)) + 0.5\n",
    "\n",
    "# Show the plot\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
